maxmustermann/pulumi
1
0
Fork 0
Code Issues Pull requests Projects Releases Wiki Activity

[sdk/go] Simplify Apply method options to reduce binary size (#6607)

Browse source 
Co-authored-by: Komal <komal@pulumi.com>
This commit is contained in:
Luke Hoban 2021-03-25 07:46:06 +11:00 committed by stack72
parent 3082ebe275
commit 11c2ae3bd2
10 changed files with 25 additions and 1762 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

16
sdk/go/pulumi/alias.go
View file

@ -82,19 +82,19 @@ func (a Alias) collapseToURN(defaultName, defaultType string, defaultParent Reso
func CreateURN(name, t, parent, project, stack StringInput) URNOutput {
var parentPrefix StringInput
if parent != nil {
parentPrefix = parent.ToStringOutput().ApplyString(func(p string) string {
parentPrefix = parent.ToStringOutput().ApplyT(func(p string) string {
return p[0:strings.LastIndex(p, "::")] + "$"
})
}).(StringOutput)
} else {
parentPrefix = All(stack, project).ApplyString(func(a []interface{}) string {
parentPrefix = All(stack, project).ApplyT(func(a []interface{}) string {
return "urn:pulumi:" + a[0].(string) + "::" + a[1].(string) + "::"
})
}).(StringOutput)
}
return All(parentPrefix, t, name).ApplyURN(func(a []interface{}) URN {
return All(parentPrefix, t, name).ApplyT(func(a []interface{}) URN {
return URN(a[0].(string) + a[1].(string) + "::" + a[2].(string))
})
}).(URNOutput)
}
// inheritedChildAlias computes the alias that should be applied to a child based on an alias applied to it's parent.
@ -103,10 +103,10 @@ func CreateURN(name, t, parent, project, stack StringInput) URNOutput {
func inheritedChildAlias(childName, parentName, childType, project, stack string, parentURN URNOutput) URNOutput {
aliasName := StringInput(String(childName))
if strings.HasPrefix(childName, parentName) {
aliasName = parentURN.ApplyString(func(urn URN) string {
aliasName = parentURN.ApplyT(func(urn URN) string {
parentPrefix := urn[strings.LastIndex(string(urn), "::")+2:]
return string(parentPrefix) + childName[len(parentName):]
})
}).(StringOutput)
}
return CreateURN(aliasName, String(childType), parentURN, String(project), String(stack))
}

8
sdk/go/pulumi/stack_reference.go
View file

@ -23,20 +23,20 @@ func (s *StackReference) GetOutput(name StringInput) AnyOutput {
// GetStringOutput returns a stack output keyed by the given name as an StringOutput
func (s *StackReference) GetStringOutput(name StringInput) StringOutput {
return s.GetOutput(name).ApplyString(func(out interface{}) string {
return s.GetOutput(name).ApplyT(func(out interface{}) string {
var res string
if out != nil {
res = out.(string)
}
return res
})
}).(StringOutput)
}
// GetIDOutput returns a stack output keyed by the given name as an IDOutput
func (s *StackReference) GetIDOutput(name StringInput) IDOutput {
return s.GetStringOutput(name).ApplyID(func(out string) ID {
return s.GetStringOutput(name).ApplyT(func(out string) ID {
return ID(out)
})
}).(IDOutput)
}
type stackReferenceArgs struct {

13
sdk/go/pulumi/templates/types_builtins.go.template
View file

@ -20,19 +20,6 @@ import (
"reflect"
)
{{range .Builtins}}
// Apply{{.Name}} is like ApplyT, but returns a {{.Name}}Output.
func (o *OutputState) Apply{{.Name}}(applier interface{}) {{.Name}}Output {
return o.ApplyT(applier).({{.Name}}Output)
}
// Apply{{.Name}}WithContext is like ApplyTWithContext, but returns a {{.Name}}Output.
func (o *OutputState) Apply{{.Name}}WithContext(ctx context.Context, applier interface{}) {{.Name}}Output {
return o.ApplyTWithContext(ctx, applier).({{.Name}}Output)
}
{{end}}
{{with $builtins := .Builtins}}
{{range $builtins}}
var {{.Name | Unexported}}Type = reflect.TypeOf((*{{.ElementType}})(nil)).Elem()

21
sdk/go/pulumi/templates/types_builtins_test.go.template
View file

@ -126,25 +126,6 @@ func TestOutputApply(t *testing.T) {
assert.NotNil(t, err)
assert.Nil(t, v)
}
// Test builtin applies.
{
out := newIntOutput()
go func() { out.resolve(42, true, false, nil) }()
{{range .Builtins}}
t.Run("Apply{{.Name}}", func(t *testing.T) {
o2 := out.Apply{{.Name}}(func(v int) {{.ElementType}} { return *new({{.ElementType}}) })
_, known, _, _, err := await(o2)
assert.True(t, known)
assert.NoError(t, err)
o2 = out.Apply{{.Name}}WithContext(context.Background(), func(_ context.Context, v int) {{.ElementType}} { return *new({{.ElementType}}) })
_, known, _, _, err = await(o2)
assert.True(t, known)
assert.NoError(t, err)
})
{{end}}
}
// Test that applies return appropriate concrete implementations of Output based on the callback type
{
out := newIntOutput()
@ -220,7 +201,7 @@ func TestOutputApply(t *testing.T) {
}
})
res5 := All(res3, res4).Apply(func (v interface{}) (interface{}, error) {
res5 := All(res3, res4).ApplyT(func (v interface{}) (interface{}, error) {
vs := v.([]interface{})
res3 := vs[0].(string)
res4 := vs[1].(*myStructType)

21
sdk/go/pulumi/types.go
View file

@ -32,13 +32,10 @@ import (
type Output interface {
ElementType() reflect.Type
Apply(applier func(interface{}) (interface{}, error)) AnyOutput
ApplyWithContext(ctx context.Context, applier func(context.Context, interface{}) (interface{}, error)) AnyOutput
ApplyT(applier interface{}) Output
ApplyTWithContext(ctx context.Context, applier interface{}) Output
getState() *OutputState
IsSecret() bool
}
var outputType = reflect.TypeOf((*Output)(nil)).Elem()
@ -308,22 +305,6 @@ func checkApplier(fn interface{}, elementType reflect.Type) reflect.Value {
return fv
}
// Apply transforms the data of the output property using the applier func. The result remains an output
// property, and accumulates all implicated dependencies, so that resources can be properly tracked using a DAG.
// This function does not block awaiting the value; instead, it spawns a Goroutine that will await its availability.
func (o *OutputState) Apply(applier func(interface{}) (interface{}, error)) AnyOutput {
return o.ApplyWithContext(context.Background(), func(_ context.Context, v interface{}) (interface{}, error) {
return applier(v)
})
}
// ApplyWithContext transforms the data of the output property using the applier func. The result remains an output
// property, and accumulates all implicated dependencies, so that resources can be properly tracked using a DAG.
// This function does not block awaiting the value; instead, it spawns a Goroutine that will await its availability.
func (o *OutputState) ApplyWithContext(ctx context.Context, applier func(context.Context, interface{}) (interface{}, error)) AnyOutput {
return o.ApplyTWithContext(ctx, applier).(AnyOutput)
}
// ApplyT transforms the data of the output property using the applier func. The result remains an output
// property, and accumulates all implicated dependencies, so that resources can be properly tracked using a DAG.
// This function does not block awaiting the value; instead, it spawns a Goroutine that will await its availability.
@ -413,7 +394,7 @@ func (o *OutputState) ApplyTWithContext(ctx context.Context, applier interface{}
}
// IsSecret returns a bool representing the secretness of the Output
func (o *OutputState) IsSecret() bool {
func IsSecret(o Output) bool {
return o.getState().secret
}

760
sdk/go/pulumi/types_builtins.go
View file

@ -20,766 +20,6 @@ import (
"reflect"
)
// ApplyArchive is like ApplyT, but returns a ArchiveOutput.
func (o *OutputState) ApplyArchive(applier interface{}) ArchiveOutput {
return o.ApplyT(applier).(ArchiveOutput)
}
// ApplyArchiveWithContext is like ApplyTWithContext, but returns a ArchiveOutput.
func (o *OutputState) ApplyArchiveWithContext(ctx context.Context, applier interface{}) ArchiveOutput {
return o.ApplyTWithContext(ctx, applier).(ArchiveOutput)
}
// ApplyArchiveArray is like ApplyT, but returns a ArchiveArrayOutput.
func (o *OutputState) ApplyArchiveArray(applier interface{}) ArchiveArrayOutput {
return o.ApplyT(applier).(ArchiveArrayOutput)
}
// ApplyArchiveArrayWithContext is like ApplyTWithContext, but returns a ArchiveArrayOutput.
func (o *OutputState) ApplyArchiveArrayWithContext(ctx context.Context, applier interface{}) ArchiveArrayOutput {
return o.ApplyTWithContext(ctx, applier).(ArchiveArrayOutput)
}
// ApplyArchiveMap is like ApplyT, but returns a ArchiveMapOutput.
func (o *OutputState) ApplyArchiveMap(applier interface{}) ArchiveMapOutput {
return o.ApplyT(applier).(ArchiveMapOutput)
}
// ApplyArchiveMapWithContext is like ApplyTWithContext, but returns a ArchiveMapOutput.
func (o *OutputState) ApplyArchiveMapWithContext(ctx context.Context, applier interface{}) ArchiveMapOutput {
return o.ApplyTWithContext(ctx, applier).(ArchiveMapOutput)
}
// ApplyArchiveArrayMap is like ApplyT, but returns a ArchiveArrayMapOutput.
func (o *OutputState) ApplyArchiveArrayMap(applier interface{}) ArchiveArrayMapOutput {
return o.ApplyT(applier).(ArchiveArrayMapOutput)
}
// ApplyArchiveArrayMapWithContext is like ApplyTWithContext, but returns a ArchiveArrayMapOutput.
func (o *OutputState) ApplyArchiveArrayMapWithContext(ctx context.Context, applier interface{}) ArchiveArrayMapOutput {
return o.ApplyTWithContext(ctx, applier).(ArchiveArrayMapOutput)
}
// ApplyArchiveMapArray is like ApplyT, but returns a ArchiveMapArrayOutput.
func (o *OutputState) ApplyArchiveMapArray(applier interface{}) ArchiveMapArrayOutput {
return o.ApplyT(applier).(ArchiveMapArrayOutput)
}
// ApplyArchiveMapArrayWithContext is like ApplyTWithContext, but returns a ArchiveMapArrayOutput.
func (o *OutputState) ApplyArchiveMapArrayWithContext(ctx context.Context, applier interface{}) ArchiveMapArrayOutput {
return o.ApplyTWithContext(ctx, applier).(ArchiveMapArrayOutput)
}
// ApplyArchiveMapMap is like ApplyT, but returns a ArchiveMapMapOutput.
func (o *OutputState) ApplyArchiveMapMap(applier interface{}) ArchiveMapMapOutput {
return o.ApplyT(applier).(ArchiveMapMapOutput)
}
// ApplyArchiveMapMapWithContext is like ApplyTWithContext, but returns a ArchiveMapMapOutput.
func (o *OutputState) ApplyArchiveMapMapWithContext(ctx context.Context, applier interface{}) ArchiveMapMapOutput {
return o.ApplyTWithContext(ctx, applier).(ArchiveMapMapOutput)
}
// ApplyArchiveArrayArray is like ApplyT, but returns a ArchiveArrayArrayOutput.
func (o *OutputState) ApplyArchiveArrayArray(applier interface{}) ArchiveArrayArrayOutput {
return o.ApplyT(applier).(ArchiveArrayArrayOutput)
}
// ApplyArchiveArrayArrayWithContext is like ApplyTWithContext, but returns a ArchiveArrayArrayOutput.
func (o *OutputState) ApplyArchiveArrayArrayWithContext(ctx context.Context, applier interface{}) ArchiveArrayArrayOutput {
return o.ApplyTWithContext(ctx, applier).(ArchiveArrayArrayOutput)
}
// ApplyAsset is like ApplyT, but returns a AssetOutput.
func (o *OutputState) ApplyAsset(applier interface{}) AssetOutput {
return o.ApplyT(applier).(AssetOutput)
}
// ApplyAssetWithContext is like ApplyTWithContext, but returns a AssetOutput.
func (o *OutputState) ApplyAssetWithContext(ctx context.Context, applier interface{}) AssetOutput {
return o.ApplyTWithContext(ctx, applier).(AssetOutput)
}
// ApplyAssetArray is like ApplyT, but returns a AssetArrayOutput.
func (o *OutputState) ApplyAssetArray(applier interface{}) AssetArrayOutput {
return o.ApplyT(applier).(AssetArrayOutput)
}
// ApplyAssetArrayWithContext is like ApplyTWithContext, but returns a AssetArrayOutput.
func (o *OutputState) ApplyAssetArrayWithContext(ctx context.Context, applier interface{}) AssetArrayOutput {
return o.ApplyTWithContext(ctx, applier).(AssetArrayOutput)
}
// ApplyAssetMap is like ApplyT, but returns a AssetMapOutput.
func (o *OutputState) ApplyAssetMap(applier interface{}) AssetMapOutput {
return o.ApplyT(applier).(AssetMapOutput)
}
// ApplyAssetMapWithContext is like ApplyTWithContext, but returns a AssetMapOutput.
func (o *OutputState) ApplyAssetMapWithContext(ctx context.Context, applier interface{}) AssetMapOutput {
return o.ApplyTWithContext(ctx, applier).(AssetMapOutput)
}
// ApplyAssetArrayMap is like ApplyT, but returns a AssetArrayMapOutput.
func (o *OutputState) ApplyAssetArrayMap(applier interface{}) AssetArrayMapOutput {
return o.ApplyT(applier).(AssetArrayMapOutput)
}
// ApplyAssetArrayMapWithContext is like ApplyTWithContext, but returns a AssetArrayMapOutput.
func (o *OutputState) ApplyAssetArrayMapWithContext(ctx context.Context, applier interface{}) AssetArrayMapOutput {
return o.ApplyTWithContext(ctx, applier).(AssetArrayMapOutput)
}
// ApplyAssetMapArray is like ApplyT, but returns a AssetMapArrayOutput.
func (o *OutputState) ApplyAssetMapArray(applier interface{}) AssetMapArrayOutput {
return o.ApplyT(applier).(AssetMapArrayOutput)
}
// ApplyAssetMapArrayWithContext is like ApplyTWithContext, but returns a AssetMapArrayOutput.
func (o *OutputState) ApplyAssetMapArrayWithContext(ctx context.Context, applier interface{}) AssetMapArrayOutput {
return o.ApplyTWithContext(ctx, applier).(AssetMapArrayOutput)
}
// ApplyAssetMapMap is like ApplyT, but returns a AssetMapMapOutput.
func (o *OutputState) ApplyAssetMapMap(applier interface{}) AssetMapMapOutput {
return o.ApplyT(applier).(AssetMapMapOutput)
}
// ApplyAssetMapMapWithContext is like ApplyTWithContext, but returns a AssetMapMapOutput.
func (o *OutputState) ApplyAssetMapMapWithContext(ctx context.Context, applier interface{}) AssetMapMapOutput {
return o.ApplyTWithContext(ctx, applier).(AssetMapMapOutput)
}
// ApplyAssetArrayArray is like ApplyT, but returns a AssetArrayArrayOutput.
func (o *OutputState) ApplyAssetArrayArray(applier interface{}) AssetArrayArrayOutput {
return o.ApplyT(applier).(AssetArrayArrayOutput)
}
// ApplyAssetArrayArrayWithContext is like ApplyTWithContext, but returns a AssetArrayArrayOutput.
func (o *OutputState) ApplyAssetArrayArrayWithContext(ctx context.Context, applier interface{}) AssetArrayArrayOutput {
return o.ApplyTWithContext(ctx, applier).(AssetArrayArrayOutput)
}
// ApplyAssetOrArchive is like ApplyT, but returns a AssetOrArchiveOutput.
func (o *OutputState) ApplyAssetOrArchive(applier interface{}) AssetOrArchiveOutput {
return o.ApplyT(applier).(AssetOrArchiveOutput)
}
// ApplyAssetOrArchiveWithContext is like ApplyTWithContext, but returns a AssetOrArchiveOutput.
func (o *OutputState) ApplyAssetOrArchiveWithContext(ctx context.Context, applier interface{}) AssetOrArchiveOutput {
return o.ApplyTWithContext(ctx, applier).(AssetOrArchiveOutput)
}
// ApplyAssetOrArchiveArray is like ApplyT, but returns a AssetOrArchiveArrayOutput.
func (o *OutputState) ApplyAssetOrArchiveArray(applier interface{}) AssetOrArchiveArrayOutput {
return o.ApplyT(applier).(AssetOrArchiveArrayOutput)
}
// ApplyAssetOrArchiveArrayWithContext is like ApplyTWithContext, but returns a AssetOrArchiveArrayOutput.
func (o *OutputState) ApplyAssetOrArchiveArrayWithContext(ctx context.Context, applier interface{}) AssetOrArchiveArrayOutput {
return o.ApplyTWithContext(ctx, applier).(AssetOrArchiveArrayOutput)
}
// ApplyAssetOrArchiveMap is like ApplyT, but returns a AssetOrArchiveMapOutput.
func (o *OutputState) ApplyAssetOrArchiveMap(applier interface{}) AssetOrArchiveMapOutput {
return o.ApplyT(applier).(AssetOrArchiveMapOutput)
}
// ApplyAssetOrArchiveMapWithContext is like ApplyTWithContext, but returns a AssetOrArchiveMapOutput.
func (o *OutputState) ApplyAssetOrArchiveMapWithContext(ctx context.Context, applier interface{}) AssetOrArchiveMapOutput {
return o.ApplyTWithContext(ctx, applier).(AssetOrArchiveMapOutput)
}
// ApplyAssetOrArchiveArrayMap is like ApplyT, but returns a AssetOrArchiveArrayMapOutput.
func (o *OutputState) ApplyAssetOrArchiveArrayMap(applier interface{}) AssetOrArchiveArrayMapOutput {
return o.ApplyT(applier).(AssetOrArchiveArrayMapOutput)
}
// ApplyAssetOrArchiveArrayMapWithContext is like ApplyTWithContext, but returns a AssetOrArchiveArrayMapOutput.
func (o *OutputState) ApplyAssetOrArchiveArrayMapWithContext(ctx context.Context, applier interface{}) AssetOrArchiveArrayMapOutput {
return o.ApplyTWithContext(ctx, applier).(AssetOrArchiveArrayMapOutput)
}
// ApplyAssetOrArchiveMapArray is like ApplyT, but returns a AssetOrArchiveMapArrayOutput.
func (o *OutputState) ApplyAssetOrArchiveMapArray(applier interface{}) AssetOrArchiveMapArrayOutput {
return o.ApplyT(applier).(AssetOrArchiveMapArrayOutput)
}
// ApplyAssetOrArchiveMapArrayWithContext is like ApplyTWithContext, but returns a AssetOrArchiveMapArrayOutput.
func (o *OutputState) ApplyAssetOrArchiveMapArrayWithContext(ctx context.Context, applier interface{}) AssetOrArchiveMapArrayOutput {
return o.ApplyTWithContext(ctx, applier).(AssetOrArchiveMapArrayOutput)
}
// ApplyAssetOrArchiveMapMap is like ApplyT, but returns a AssetOrArchiveMapMapOutput.
func (o *OutputState) ApplyAssetOrArchiveMapMap(applier interface{}) AssetOrArchiveMapMapOutput {
return o.ApplyT(applier).(AssetOrArchiveMapMapOutput)
}
// ApplyAssetOrArchiveMapMapWithContext is like ApplyTWithContext, but returns a AssetOrArchiveMapMapOutput.
func (o *OutputState) ApplyAssetOrArchiveMapMapWithContext(ctx context.Context, applier interface{}) AssetOrArchiveMapMapOutput {
return o.ApplyTWithContext(ctx, applier).(AssetOrArchiveMapMapOutput)
}
// ApplyAssetOrArchiveArrayArray is like ApplyT, but returns a AssetOrArchiveArrayArrayOutput.
func (o *OutputState) ApplyAssetOrArchiveArrayArray(applier interface{}) AssetOrArchiveArrayArrayOutput {
return o.ApplyT(applier).(AssetOrArchiveArrayArrayOutput)
}
// ApplyAssetOrArchiveArrayArrayWithContext is like ApplyTWithContext, but returns a AssetOrArchiveArrayArrayOutput.
func (o *OutputState) ApplyAssetOrArchiveArrayArrayWithContext(ctx context.Context, applier interface{}) AssetOrArchiveArrayArrayOutput {
return o.ApplyTWithContext(ctx, applier).(AssetOrArchiveArrayArrayOutput)
}
// ApplyBool is like ApplyT, but returns a BoolOutput.
func (o *OutputState) ApplyBool(applier interface{}) BoolOutput {
return o.ApplyT(applier).(BoolOutput)
}
// ApplyBoolWithContext is like ApplyTWithContext, but returns a BoolOutput.
func (o *OutputState) ApplyBoolWithContext(ctx context.Context, applier interface{}) BoolOutput {
return o.ApplyTWithContext(ctx, applier).(BoolOutput)
}
// ApplyBoolPtr is like ApplyT, but returns a BoolPtrOutput.
func (o *OutputState) ApplyBoolPtr(applier interface{}) BoolPtrOutput {
return o.ApplyT(applier).(BoolPtrOutput)
}
// ApplyBoolPtrWithContext is like ApplyTWithContext, but returns a BoolPtrOutput.
func (o *OutputState) ApplyBoolPtrWithContext(ctx context.Context, applier interface{}) BoolPtrOutput {
return o.ApplyTWithContext(ctx, applier).(BoolPtrOutput)
}
// ApplyBoolArray is like ApplyT, but returns a BoolArrayOutput.
func (o *OutputState) ApplyBoolArray(applier interface{}) BoolArrayOutput {
return o.ApplyT(applier).(BoolArrayOutput)
}
// ApplyBoolArrayWithContext is like ApplyTWithContext, but returns a BoolArrayOutput.
func (o *OutputState) ApplyBoolArrayWithContext(ctx context.Context, applier interface{}) BoolArrayOutput {
return o.ApplyTWithContext(ctx, applier).(BoolArrayOutput)
}
// ApplyBoolMap is like ApplyT, but returns a BoolMapOutput.
func (o *OutputState) ApplyBoolMap(applier interface{}) BoolMapOutput {
return o.ApplyT(applier).(BoolMapOutput)
}
// ApplyBoolMapWithContext is like ApplyTWithContext, but returns a BoolMapOutput.
func (o *OutputState) ApplyBoolMapWithContext(ctx context.Context, applier interface{}) BoolMapOutput {
return o.ApplyTWithContext(ctx, applier).(BoolMapOutput)
}
// ApplyBoolArrayMap is like ApplyT, but returns a BoolArrayMapOutput.
func (o *OutputState) ApplyBoolArrayMap(applier interface{}) BoolArrayMapOutput {
return o.ApplyT(applier).(BoolArrayMapOutput)
}
// ApplyBoolArrayMapWithContext is like ApplyTWithContext, but returns a BoolArrayMapOutput.
func (o *OutputState) ApplyBoolArrayMapWithContext(ctx context.Context, applier interface{}) BoolArrayMapOutput {
return o.ApplyTWithContext(ctx, applier).(BoolArrayMapOutput)
}
// ApplyBoolMapArray is like ApplyT, but returns a BoolMapArrayOutput.
func (o *OutputState) ApplyBoolMapArray(applier interface{}) BoolMapArrayOutput {
return o.ApplyT(applier).(BoolMapArrayOutput)
}
// ApplyBoolMapArrayWithContext is like ApplyTWithContext, but returns a BoolMapArrayOutput.
func (o *OutputState) ApplyBoolMapArrayWithContext(ctx context.Context, applier interface{}) BoolMapArrayOutput {
return o.ApplyTWithContext(ctx, applier).(BoolMapArrayOutput)
}
// ApplyBoolMapMap is like ApplyT, but returns a BoolMapMapOutput.
func (o *OutputState) ApplyBoolMapMap(applier interface{}) BoolMapMapOutput {
return o.ApplyT(applier).(BoolMapMapOutput)
}
// ApplyBoolMapMapWithContext is like ApplyTWithContext, but returns a BoolMapMapOutput.
func (o *OutputState) ApplyBoolMapMapWithContext(ctx context.Context, applier interface{}) BoolMapMapOutput {
return o.ApplyTWithContext(ctx, applier).(BoolMapMapOutput)
}
// ApplyBoolArrayArray is like ApplyT, but returns a BoolArrayArrayOutput.
func (o *OutputState) ApplyBoolArrayArray(applier interface{}) BoolArrayArrayOutput {
return o.ApplyT(applier).(BoolArrayArrayOutput)
}
// ApplyBoolArrayArrayWithContext is like ApplyTWithContext, but returns a BoolArrayArrayOutput.
func (o *OutputState) ApplyBoolArrayArrayWithContext(ctx context.Context, applier interface{}) BoolArrayArrayOutput {
return o.ApplyTWithContext(ctx, applier).(BoolArrayArrayOutput)
}
// ApplyFloat64 is like ApplyT, but returns a Float64Output.
func (o *OutputState) ApplyFloat64(applier interface{}) Float64Output {
return o.ApplyT(applier).(Float64Output)
}
// ApplyFloat64WithContext is like ApplyTWithContext, but returns a Float64Output.
func (o *OutputState) ApplyFloat64WithContext(ctx context.Context, applier interface{}) Float64Output {
return o.ApplyTWithContext(ctx, applier).(Float64Output)
}
// ApplyFloat64Ptr is like ApplyT, but returns a Float64PtrOutput.
func (o *OutputState) ApplyFloat64Ptr(applier interface{}) Float64PtrOutput {
return o.ApplyT(applier).(Float64PtrOutput)
}
// ApplyFloat64PtrWithContext is like ApplyTWithContext, but returns a Float64PtrOutput.
func (o *OutputState) ApplyFloat64PtrWithContext(ctx context.Context, applier interface{}) Float64PtrOutput {
return o.ApplyTWithContext(ctx, applier).(Float64PtrOutput)
}
// ApplyFloat64Array is like ApplyT, but returns a Float64ArrayOutput.
func (o *OutputState) ApplyFloat64Array(applier interface{}) Float64ArrayOutput {
return o.ApplyT(applier).(Float64ArrayOutput)
}
// ApplyFloat64ArrayWithContext is like ApplyTWithContext, but returns a Float64ArrayOutput.
func (o *OutputState) ApplyFloat64ArrayWithContext(ctx context.Context, applier interface{}) Float64ArrayOutput {
return o.ApplyTWithContext(ctx, applier).(Float64ArrayOutput)
}
// ApplyFloat64Map is like ApplyT, but returns a Float64MapOutput.
func (o *OutputState) ApplyFloat64Map(applier interface{}) Float64MapOutput {
return o.ApplyT(applier).(Float64MapOutput)
}
// ApplyFloat64MapWithContext is like ApplyTWithContext, but returns a Float64MapOutput.
func (o *OutputState) ApplyFloat64MapWithContext(ctx context.Context, applier interface{}) Float64MapOutput {
return o.ApplyTWithContext(ctx, applier).(Float64MapOutput)
}
// ApplyFloat64ArrayMap is like ApplyT, but returns a Float64ArrayMapOutput.
func (o *OutputState) ApplyFloat64ArrayMap(applier interface{}) Float64ArrayMapOutput {
return o.ApplyT(applier).(Float64ArrayMapOutput)
}
// ApplyFloat64ArrayMapWithContext is like ApplyTWithContext, but returns a Float64ArrayMapOutput.
func (o *OutputState) ApplyFloat64ArrayMapWithContext(ctx context.Context, applier interface{}) Float64ArrayMapOutput {
return o.ApplyTWithContext(ctx, applier).(Float64ArrayMapOutput)
}
// ApplyFloat64MapArray is like ApplyT, but returns a Float64MapArrayOutput.
func (o *OutputState) ApplyFloat64MapArray(applier interface{}) Float64MapArrayOutput {
return o.ApplyT(applier).(Float64MapArrayOutput)
}
// ApplyFloat64MapArrayWithContext is like ApplyTWithContext, but returns a Float64MapArrayOutput.
func (o *OutputState) ApplyFloat64MapArrayWithContext(ctx context.Context, applier interface{}) Float64MapArrayOutput {
return o.ApplyTWithContext(ctx, applier).(Float64MapArrayOutput)
}
// ApplyFloat64MapMap is like ApplyT, but returns a Float64MapMapOutput.
func (o *OutputState) ApplyFloat64MapMap(applier interface{}) Float64MapMapOutput {
return o.ApplyT(applier).(Float64MapMapOutput)
}
// ApplyFloat64MapMapWithContext is like ApplyTWithContext, but returns a Float64MapMapOutput.
func (o *OutputState) ApplyFloat64MapMapWithContext(ctx context.Context, applier interface{}) Float64MapMapOutput {
return o.ApplyTWithContext(ctx, applier).(Float64MapMapOutput)
}
// ApplyFloat64ArrayArray is like ApplyT, but returns a Float64ArrayArrayOutput.
func (o *OutputState) ApplyFloat64ArrayArray(applier interface{}) Float64ArrayArrayOutput {
return o.ApplyT(applier).(Float64ArrayArrayOutput)
}
// ApplyFloat64ArrayArrayWithContext is like ApplyTWithContext, but returns a Float64ArrayArrayOutput.
func (o *OutputState) ApplyFloat64ArrayArrayWithContext(ctx context.Context, applier interface{}) Float64ArrayArrayOutput {
return o.ApplyTWithContext(ctx, applier).(Float64ArrayArrayOutput)
}
// ApplyID is like ApplyT, but returns a IDOutput.
func (o *OutputState) ApplyID(applier interface{}) IDOutput {
return o.ApplyT(applier).(IDOutput)
}
// ApplyIDWithContext is like ApplyTWithContext, but returns a IDOutput.
func (o *OutputState) ApplyIDWithContext(ctx context.Context, applier interface{}) IDOutput {
return o.ApplyTWithContext(ctx, applier).(IDOutput)
}
// ApplyIDPtr is like ApplyT, but returns a IDPtrOutput.
func (o *OutputState) ApplyIDPtr(applier interface{}) IDPtrOutput {
return o.ApplyT(applier).(IDPtrOutput)
}
// ApplyIDPtrWithContext is like ApplyTWithContext, but returns a IDPtrOutput.
func (o *OutputState) ApplyIDPtrWithContext(ctx context.Context, applier interface{}) IDPtrOutput {
return o.ApplyTWithContext(ctx, applier).(IDPtrOutput)
}
// ApplyIDArray is like ApplyT, but returns a IDArrayOutput.
func (o *OutputState) ApplyIDArray(applier interface{}) IDArrayOutput {
return o.ApplyT(applier).(IDArrayOutput)
}
// ApplyIDArrayWithContext is like ApplyTWithContext, but returns a IDArrayOutput.
func (o *OutputState) ApplyIDArrayWithContext(ctx context.Context, applier interface{}) IDArrayOutput {
return o.ApplyTWithContext(ctx, applier).(IDArrayOutput)
}
// ApplyIDMap is like ApplyT, but returns a IDMapOutput.
func (o *OutputState) ApplyIDMap(applier interface{}) IDMapOutput {
return o.ApplyT(applier).(IDMapOutput)
}
// ApplyIDMapWithContext is like ApplyTWithContext, but returns a IDMapOutput.
func (o *OutputState) ApplyIDMapWithContext(ctx context.Context, applier interface{}) IDMapOutput {
return o.ApplyTWithContext(ctx, applier).(IDMapOutput)
}
// ApplyIDArrayMap is like ApplyT, but returns a IDArrayMapOutput.
func (o *OutputState) ApplyIDArrayMap(applier interface{}) IDArrayMapOutput {
return o.ApplyT(applier).(IDArrayMapOutput)
}
// ApplyIDArrayMapWithContext is like ApplyTWithContext, but returns a IDArrayMapOutput.
func (o *OutputState) ApplyIDArrayMapWithContext(ctx context.Context, applier interface{}) IDArrayMapOutput {
return o.ApplyTWithContext(ctx, applier).(IDArrayMapOutput)
}
// ApplyIDMapArray is like ApplyT, but returns a IDMapArrayOutput.
func (o *OutputState) ApplyIDMapArray(applier interface{}) IDMapArrayOutput {
return o.ApplyT(applier).(IDMapArrayOutput)
}
// ApplyIDMapArrayWithContext is like ApplyTWithContext, but returns a IDMapArrayOutput.
func (o *OutputState) ApplyIDMapArrayWithContext(ctx context.Context, applier interface{}) IDMapArrayOutput {
return o.ApplyTWithContext(ctx, applier).(IDMapArrayOutput)
}
// ApplyIDMapMap is like ApplyT, but returns a IDMapMapOutput.
func (o *OutputState) ApplyIDMapMap(applier interface{}) IDMapMapOutput {
return o.ApplyT(applier).(IDMapMapOutput)
}
// ApplyIDMapMapWithContext is like ApplyTWithContext, but returns a IDMapMapOutput.
func (o *OutputState) ApplyIDMapMapWithContext(ctx context.Context, applier interface{}) IDMapMapOutput {
return o.ApplyTWithContext(ctx, applier).(IDMapMapOutput)
}
// ApplyIDArrayArray is like ApplyT, but returns a IDArrayArrayOutput.
func (o *OutputState) ApplyIDArrayArray(applier interface{}) IDArrayArrayOutput {
return o.ApplyT(applier).(IDArrayArrayOutput)
}
// ApplyIDArrayArrayWithContext is like ApplyTWithContext, but returns a IDArrayArrayOutput.
func (o *OutputState) ApplyIDArrayArrayWithContext(ctx context.Context, applier interface{}) IDArrayArrayOutput {
return o.ApplyTWithContext(ctx, applier).(IDArrayArrayOutput)
}
// ApplyArray is like ApplyT, but returns a ArrayOutput.
func (o *OutputState) ApplyArray(applier interface{}) ArrayOutput {
return o.ApplyT(applier).(ArrayOutput)
}
// ApplyArrayWithContext is like ApplyTWithContext, but returns a ArrayOutput.
func (o *OutputState) ApplyArrayWithContext(ctx context.Context, applier interface{}) ArrayOutput {
return o.ApplyTWithContext(ctx, applier).(ArrayOutput)
}
// ApplyMap is like ApplyT, but returns a MapOutput.
func (o *OutputState) ApplyMap(applier interface{}) MapOutput {
return o.ApplyT(applier).(MapOutput)
}
// ApplyMapWithContext is like ApplyTWithContext, but returns a MapOutput.
func (o *OutputState) ApplyMapWithContext(ctx context.Context, applier interface{}) MapOutput {
return o.ApplyTWithContext(ctx, applier).(MapOutput)
}
// ApplyArrayMap is like ApplyT, but returns a ArrayMapOutput.
func (o *OutputState) ApplyArrayMap(applier interface{}) ArrayMapOutput {
return o.ApplyT(applier).(ArrayMapOutput)
}
// ApplyArrayMapWithContext is like ApplyTWithContext, but returns a ArrayMapOutput.
func (o *OutputState) ApplyArrayMapWithContext(ctx context.Context, applier interface{}) ArrayMapOutput {
return o.ApplyTWithContext(ctx, applier).(ArrayMapOutput)
}
// ApplyMapArray is like ApplyT, but returns a MapArrayOutput.
func (o *OutputState) ApplyMapArray(applier interface{}) MapArrayOutput {
return o.ApplyT(applier).(MapArrayOutput)
}
// ApplyMapArrayWithContext is like ApplyTWithContext, but returns a MapArrayOutput.
func (o *OutputState) ApplyMapArrayWithContext(ctx context.Context, applier interface{}) MapArrayOutput {
return o.ApplyTWithContext(ctx, applier).(MapArrayOutput)
}
// ApplyMapMap is like ApplyT, but returns a MapMapOutput.
func (o *OutputState) ApplyMapMap(applier interface{}) MapMapOutput {
return o.ApplyT(applier).(MapMapOutput)
}
// ApplyMapMapWithContext is like ApplyTWithContext, but returns a MapMapOutput.
func (o *OutputState) ApplyMapMapWithContext(ctx context.Context, applier interface{}) MapMapOutput {
return o.ApplyTWithContext(ctx, applier).(MapMapOutput)
}
// ApplyArrayArray is like ApplyT, but returns a ArrayArrayOutput.
func (o *OutputState) ApplyArrayArray(applier interface{}) ArrayArrayOutput {
return o.ApplyT(applier).(ArrayArrayOutput)
}
// ApplyArrayArrayWithContext is like ApplyTWithContext, but returns a ArrayArrayOutput.
func (o *OutputState) ApplyArrayArrayWithContext(ctx context.Context, applier interface{}) ArrayArrayOutput {
return o.ApplyTWithContext(ctx, applier).(ArrayArrayOutput)
}
// ApplyArrayArrayMap is like ApplyT, but returns a ArrayArrayMapOutput.
func (o *OutputState) ApplyArrayArrayMap(applier interface{}) ArrayArrayMapOutput {
return o.ApplyT(applier).(ArrayArrayMapOutput)
}
// ApplyArrayArrayMapWithContext is like ApplyTWithContext, but returns a ArrayArrayMapOutput.
func (o *OutputState) ApplyArrayArrayMapWithContext(ctx context.Context, applier interface{}) ArrayArrayMapOutput {
return o.ApplyTWithContext(ctx, applier).(ArrayArrayMapOutput)
}
// ApplyInt is like ApplyT, but returns a IntOutput.
func (o *OutputState) ApplyInt(applier interface{}) IntOutput {
return o.ApplyT(applier).(IntOutput)
}
// ApplyIntWithContext is like ApplyTWithContext, but returns a IntOutput.
func (o *OutputState) ApplyIntWithContext(ctx context.Context, applier interface{}) IntOutput {
return o.ApplyTWithContext(ctx, applier).(IntOutput)
}
// ApplyIntPtr is like ApplyT, but returns a IntPtrOutput.
func (o *OutputState) ApplyIntPtr(applier interface{}) IntPtrOutput {
return o.ApplyT(applier).(IntPtrOutput)
}
// ApplyIntPtrWithContext is like ApplyTWithContext, but returns a IntPtrOutput.
func (o *OutputState) ApplyIntPtrWithContext(ctx context.Context, applier interface{}) IntPtrOutput {
return o.ApplyTWithContext(ctx, applier).(IntPtrOutput)
}
// ApplyIntArray is like ApplyT, but returns a IntArrayOutput.
func (o *OutputState) ApplyIntArray(applier interface{}) IntArrayOutput {
return o.ApplyT(applier).(IntArrayOutput)
}
// ApplyIntArrayWithContext is like ApplyTWithContext, but returns a IntArrayOutput.
func (o *OutputState) ApplyIntArrayWithContext(ctx context.Context, applier interface{}) IntArrayOutput {
return o.ApplyTWithContext(ctx, applier).(IntArrayOutput)
}
// ApplyIntMap is like ApplyT, but returns a IntMapOutput.
func (o *OutputState) ApplyIntMap(applier interface{}) IntMapOutput {
return o.ApplyT(applier).(IntMapOutput)
}
// ApplyIntMapWithContext is like ApplyTWithContext, but returns a IntMapOutput.
func (o *OutputState) ApplyIntMapWithContext(ctx context.Context, applier interface{}) IntMapOutput {
return o.ApplyTWithContext(ctx, applier).(IntMapOutput)
}
// ApplyIntArrayMap is like ApplyT, but returns a IntArrayMapOutput.
func (o *OutputState) ApplyIntArrayMap(applier interface{}) IntArrayMapOutput {
return o.ApplyT(applier).(IntArrayMapOutput)
}
// ApplyIntArrayMapWithContext is like ApplyTWithContext, but returns a IntArrayMapOutput.
func (o *OutputState) ApplyIntArrayMapWithContext(ctx context.Context, applier interface{}) IntArrayMapOutput {
return o.ApplyTWithContext(ctx, applier).(IntArrayMapOutput)
}
// ApplyIntMapArray is like ApplyT, but returns a IntMapArrayOutput.
func (o *OutputState) ApplyIntMapArray(applier interface{}) IntMapArrayOutput {
return o.ApplyT(applier).(IntMapArrayOutput)
}
// ApplyIntMapArrayWithContext is like ApplyTWithContext, but returns a IntMapArrayOutput.
func (o *OutputState) ApplyIntMapArrayWithContext(ctx context.Context, applier interface{}) IntMapArrayOutput {
return o.ApplyTWithContext(ctx, applier).(IntMapArrayOutput)
}
// ApplyIntMapMap is like ApplyT, but returns a IntMapMapOutput.
func (o *OutputState) ApplyIntMapMap(applier interface{}) IntMapMapOutput {
return o.ApplyT(applier).(IntMapMapOutput)
}
// ApplyIntMapMapWithContext is like ApplyTWithContext, but returns a IntMapMapOutput.
func (o *OutputState) ApplyIntMapMapWithContext(ctx context.Context, applier interface{}) IntMapMapOutput {
return o.ApplyTWithContext(ctx, applier).(IntMapMapOutput)
}
// ApplyIntArrayArray is like ApplyT, but returns a IntArrayArrayOutput.
func (o *OutputState) ApplyIntArrayArray(applier interface{}) IntArrayArrayOutput {
return o.ApplyT(applier).(IntArrayArrayOutput)
}
// ApplyIntArrayArrayWithContext is like ApplyTWithContext, but returns a IntArrayArrayOutput.
func (o *OutputState) ApplyIntArrayArrayWithContext(ctx context.Context, applier interface{}) IntArrayArrayOutput {
return o.ApplyTWithContext(ctx, applier).(IntArrayArrayOutput)
}
// ApplyString is like ApplyT, but returns a StringOutput.
func (o *OutputState) ApplyString(applier interface{}) StringOutput {
return o.ApplyT(applier).(StringOutput)
}
// ApplyStringWithContext is like ApplyTWithContext, but returns a StringOutput.
func (o *OutputState) ApplyStringWithContext(ctx context.Context, applier interface{}) StringOutput {
return o.ApplyTWithContext(ctx, applier).(StringOutput)
}
// ApplyStringPtr is like ApplyT, but returns a StringPtrOutput.
func (o *OutputState) ApplyStringPtr(applier interface{}) StringPtrOutput {
return o.ApplyT(applier).(StringPtrOutput)
}
// ApplyStringPtrWithContext is like ApplyTWithContext, but returns a StringPtrOutput.
func (o *OutputState) ApplyStringPtrWithContext(ctx context.Context, applier interface{}) StringPtrOutput {
return o.ApplyTWithContext(ctx, applier).(StringPtrOutput)
}
// ApplyStringArray is like ApplyT, but returns a StringArrayOutput.
func (o *OutputState) ApplyStringArray(applier interface{}) StringArrayOutput {
return o.ApplyT(applier).(StringArrayOutput)
}
// ApplyStringArrayWithContext is like ApplyTWithContext, but returns a StringArrayOutput.
func (o *OutputState) ApplyStringArrayWithContext(ctx context.Context, applier interface{}) StringArrayOutput {
return o.ApplyTWithContext(ctx, applier).(StringArrayOutput)
}
// ApplyStringMap is like ApplyT, but returns a StringMapOutput.
func (o *OutputState) ApplyStringMap(applier interface{}) StringMapOutput {
return o.ApplyT(applier).(StringMapOutput)
}
// ApplyStringMapWithContext is like ApplyTWithContext, but returns a StringMapOutput.
func (o *OutputState) ApplyStringMapWithContext(ctx context.Context, applier interface{}) StringMapOutput {
return o.ApplyTWithContext(ctx, applier).(StringMapOutput)
}
// ApplyStringArrayMap is like ApplyT, but returns a StringArrayMapOutput.
func (o *OutputState) ApplyStringArrayMap(applier interface{}) StringArrayMapOutput {
return o.ApplyT(applier).(StringArrayMapOutput)
}
// ApplyStringArrayMapWithContext is like ApplyTWithContext, but returns a StringArrayMapOutput.
func (o *OutputState) ApplyStringArrayMapWithContext(ctx context.Context, applier interface{}) StringArrayMapOutput {
return o.ApplyTWithContext(ctx, applier).(StringArrayMapOutput)
}
// ApplyStringMapArray is like ApplyT, but returns a StringMapArrayOutput.
func (o *OutputState) ApplyStringMapArray(applier interface{}) StringMapArrayOutput {
return o.ApplyT(applier).(StringMapArrayOutput)
}
// ApplyStringMapArrayWithContext is like ApplyTWithContext, but returns a StringMapArrayOutput.
func (o *OutputState) ApplyStringMapArrayWithContext(ctx context.Context, applier interface{}) StringMapArrayOutput {
return o.ApplyTWithContext(ctx, applier).(StringMapArrayOutput)
}
// ApplyStringMapMap is like ApplyT, but returns a StringMapMapOutput.
func (o *OutputState) ApplyStringMapMap(applier interface{}) StringMapMapOutput {
return o.ApplyT(applier).(StringMapMapOutput)
}
// ApplyStringMapMapWithContext is like ApplyTWithContext, but returns a StringMapMapOutput.
func (o *OutputState) ApplyStringMapMapWithContext(ctx context.Context, applier interface{}) StringMapMapOutput {
return o.ApplyTWithContext(ctx, applier).(StringMapMapOutput)
}
// ApplyStringArrayArray is like ApplyT, but returns a StringArrayArrayOutput.
func (o *OutputState) ApplyStringArrayArray(applier interface{}) StringArrayArrayOutput {
return o.ApplyT(applier).(StringArrayArrayOutput)
}
// ApplyStringArrayArrayWithContext is like ApplyTWithContext, but returns a StringArrayArrayOutput.
func (o *OutputState) ApplyStringArrayArrayWithContext(ctx context.Context, applier interface{}) StringArrayArrayOutput {
return o.ApplyTWithContext(ctx, applier).(StringArrayArrayOutput)
}
// ApplyURN is like ApplyT, but returns a URNOutput.
func (o *OutputState) ApplyURN(applier interface{}) URNOutput {
return o.ApplyT(applier).(URNOutput)
}
// ApplyURNWithContext is like ApplyTWithContext, but returns a URNOutput.
func (o *OutputState) ApplyURNWithContext(ctx context.Context, applier interface{}) URNOutput {
return o.ApplyTWithContext(ctx, applier).(URNOutput)
}
// ApplyURNPtr is like ApplyT, but returns a URNPtrOutput.
func (o *OutputState) ApplyURNPtr(applier interface{}) URNPtrOutput {
return o.ApplyT(applier).(URNPtrOutput)
}
// ApplyURNPtrWithContext is like ApplyTWithContext, but returns a URNPtrOutput.
func (o *OutputState) ApplyURNPtrWithContext(ctx context.Context, applier interface{}) URNPtrOutput {
return o.ApplyTWithContext(ctx, applier).(URNPtrOutput)
}
// ApplyURNArray is like ApplyT, but returns a URNArrayOutput.
func (o *OutputState) ApplyURNArray(applier interface{}) URNArrayOutput {
return o.ApplyT(applier).(URNArrayOutput)
}
// ApplyURNArrayWithContext is like ApplyTWithContext, but returns a URNArrayOutput.
func (o *OutputState) ApplyURNArrayWithContext(ctx context.Context, applier interface{}) URNArrayOutput {
return o.ApplyTWithContext(ctx, applier).(URNArrayOutput)
}
// ApplyURNMap is like ApplyT, but returns a URNMapOutput.
func (o *OutputState) ApplyURNMap(applier interface{}) URNMapOutput {
return o.ApplyT(applier).(URNMapOutput)
}
// ApplyURNMapWithContext is like ApplyTWithContext, but returns a URNMapOutput.
func (o *OutputState) ApplyURNMapWithContext(ctx context.Context, applier interface{}) URNMapOutput {
return o.ApplyTWithContext(ctx, applier).(URNMapOutput)
}
// ApplyURNArrayMap is like ApplyT, but returns a URNArrayMapOutput.
func (o *OutputState) ApplyURNArrayMap(applier interface{}) URNArrayMapOutput {
return o.ApplyT(applier).(URNArrayMapOutput)
}
// ApplyURNArrayMapWithContext is like ApplyTWithContext, but returns a URNArrayMapOutput.
func (o *OutputState) ApplyURNArrayMapWithContext(ctx context.Context, applier interface{}) URNArrayMapOutput {
return o.ApplyTWithContext(ctx, applier).(URNArrayMapOutput)
}
// ApplyURNMapArray is like ApplyT, but returns a URNMapArrayOutput.
func (o *OutputState) ApplyURNMapArray(applier interface{}) URNMapArrayOutput {
return o.ApplyT(applier).(URNMapArrayOutput)
}
// ApplyURNMapArrayWithContext is like ApplyTWithContext, but returns a URNMapArrayOutput.
func (o *OutputState) ApplyURNMapArrayWithContext(ctx context.Context, applier interface{}) URNMapArrayOutput {
return o.ApplyTWithContext(ctx, applier).(URNMapArrayOutput)
}
// ApplyURNMapMap is like ApplyT, but returns a URNMapMapOutput.
func (o *OutputState) ApplyURNMapMap(applier interface{}) URNMapMapOutput {
return o.ApplyT(applier).(URNMapMapOutput)
}
// ApplyURNMapMapWithContext is like ApplyTWithContext, but returns a URNMapMapOutput.
func (o *OutputState) ApplyURNMapMapWithContext(ctx context.Context, applier interface{}) URNMapMapOutput {
return o.ApplyTWithContext(ctx, applier).(URNMapMapOutput)
}
// ApplyURNArrayArray is like ApplyT, but returns a URNArrayArrayOutput.
func (o *OutputState) ApplyURNArrayArray(applier interface{}) URNArrayArrayOutput {
return o.ApplyT(applier).(URNArrayArrayOutput)
}
// ApplyURNArrayArrayWithContext is like ApplyTWithContext, but returns a URNArrayArrayOutput.
func (o *OutputState) ApplyURNArrayArrayWithContext(ctx context.Context, applier interface{}) URNArrayArrayOutput {
return o.ApplyTWithContext(ctx, applier).(URNArrayArrayOutput)
}
var archiveType = reflect.TypeOf((*Archive)(nil)).Elem()
// ArchiveInput is an input type that accepts Archive and ArchiveOutput values.

928
sdk/go/pulumi/types_builtins_test.go
View file

@ -126,932 +126,6 @@ func TestOutputApply(t *testing.T) {
assert.NotNil(t, err)
assert.Nil(t, v)
}
// Test builtin applies.
{
out := newIntOutput()
go func() { out.resolve(42, true, false, nil) }()
t.Run("ApplyArchive", func(t *testing.T) {
o2 := out.ApplyArchive(func(v int) Archive { return *new(Archive) })
_, known, _, _, err := await(o2)
assert.True(t, known)
assert.NoError(t, err)
o2 = out.ApplyArchiveWithContext(context.Background(), func(_ context.Context, v int) Archive { return *new(Archive) })
_, known, _, _, err = await(o2)
assert.True(t, known)
assert.NoError(t, err)
})
t.Run("ApplyArchiveArray", func(t *testing.T) {
o2 := out.ApplyArchiveArray(func(v int) []Archive { return *new([]Archive) })
_, known, _, _, err := await(o2)
assert.True(t, known)
assert.NoError(t, err)
o2 = out.ApplyArchiveArrayWithContext(context.Background(), func(_ context.Context, v int) []Archive { return *new([]Archive) })
_, known, _, _, err = await(o2)
assert.True(t, known)
assert.NoError(t, err)
})
t.Run("ApplyArchiveMap", func(t *testing.T) {
o2 := out.ApplyArchiveMap(func(v int) map[string]Archive { return *new(map[string]Archive) })
_, known, _, _, err := await(o2)
assert.True(t, known)
assert.NoError(t, err)
o2 = out.ApplyArchiveMapWithContext(context.Background(), func(_ context.Context, v int) map[string]Archive { return *new(map[string]Archive) })
_, known, _, _, err = await(o2)
assert.True(t, known)
assert.NoError(t, err)
})
t.Run("ApplyArchiveArrayMap", func(t *testing.T) {
o2 := out.ApplyArchiveArrayMap(func(v int) map[string][]Archive { return *new(map[string][]Archive) })
_, known, _, _, err := await(o2)
assert.True(t, known)
assert.NoError(t, err)
o2 = out.ApplyArchiveArrayMapWithContext(context.Background(), func(_ context.Context, v int) map[string][]Archive { return *new(map[string][]Archive) })
_, known, _, _, err = await(o2)
assert.True(t, known)
assert.NoError(t, err)
})
t.Run("ApplyArchiveMapArray", func(t *testing.T) {
o2 := out.ApplyArchiveMapArray(func(v int) []map[string]Archive { return *new([]map[string]Archive) })
_, known, _, _, err := await(o2)
assert.True(t, known)
assert.NoError(t, err)
o2 = out.ApplyArchiveMapArrayWithContext(context.Background(), func(_ context.Context, v int) []map[string]Archive { return *new([]map[string]Archive) })
_, known, _, _, err = await(o2)
assert.True(t, known)
assert.NoError(t, err)
})
t.Run("ApplyArchiveMapMap", func(t *testing.T) {
o2 := out.ApplyArchiveMapMap(func(v int) map[string]map[string]Archive { return *new(map[string]map[string]Archive) })
_, known, _, _, err := await(o2)
assert.True(t, known)
assert.NoError(t, err)
o2 = out.ApplyArchiveMapMapWithContext(context.Background(), func(_ context.Context, v int) map[string]map[string]Archive {
return *new(map[string]map[string]Archive)
})
_, known, _, _, err = await(o2)
assert.True(t, known)
assert.NoError(t, err)
})
t.Run("ApplyArchiveArrayArray", func(t *testing.T) {
o2 := out.ApplyArchiveArrayArray(func(v int) [][]Archive { return *new([][]Archive) })
_, known, _, _, err := await(o2)
assert.True(t, known)
assert.NoError(t, err)
o2 = out.ApplyArchiveArrayArrayWithContext(context.Background(), func(_ context.Context, v int) [][]Archive { return *new([][]Archive) })
_, known, _, _, err = await(o2)
assert.True(t, known)
assert.NoError(t, err)
})
t.Run("ApplyAsset", func(t *testing.T) {
o2 := out.ApplyAsset(func(v int) Asset { return *new(Asset) })
_, known, _, _, err := await(o2)
assert.True(t, known)
assert.NoError(t, err)
o2 = out.ApplyAssetWithContext(context.Background(), func(_ context.Context, v int) Asset { return *new(Asset) })
_, known, _, _, err = await(o2)
assert.True(t, known)
assert.NoError(t, err)
})
t.Run("ApplyAssetArray", func(t *testing.T) {
o2 := out.ApplyAssetArray(func(v int) []Asset { return *new([]Asset) })
_, known, _, _, err := await(o2)
assert.True(t, known)
assert.NoError(t, err)
o2 = out.ApplyAssetArrayWithContext(context.Background(), func(_ context.Context, v int) []Asset { return *new([]Asset) })
_, known, _, _, err = await(o2)
assert.True(t, known)
assert.NoError(t, err)
})
t.Run("ApplyAssetMap", func(t *testing.T) {
o2 := out.ApplyAssetMap(func(v int) map[string]Asset { return *new(map[string]Asset) })
_, known, _, _, err := await(o2)
assert.True(t, known)
assert.NoError(t, err)
o2 = out.ApplyAssetMapWithContext(context.Background(), func(_ context.Context, v int) map[string]Asset { return *new(map[string]Asset) })
_, known, _, _, err = await(o2)
assert.True(t, known)
assert.NoError(t, err)
})
t.Run("ApplyAssetArrayMap", func(t *testing.T) {
o2 := out.ApplyAssetArrayMap(func(v int) map[string][]Asset { return *new(map[string][]Asset) })
_, known, _, _, err := await(o2)
assert.True(t, known)
assert.NoError(t, err)
o2 = out.ApplyAssetArrayMapWithContext(context.Background(), func(_ context.Context, v int) map[string][]Asset { return *new(map[string][]Asset) })
_, known, _, _, err = await(o2)
assert.True(t, known)
assert.NoError(t, err)
})
t.Run("ApplyAssetMapArray", func(t *testing.T) {
o2 := out.ApplyAssetMapArray(func(v int) []map[string]Asset { return *new([]map[string]Asset) })
_, known, _, _, err := await(o2)
assert.True(t, known)
assert.NoError(t, err)
o2 = out.ApplyAssetMapArrayWithContext(context.Background(), func(_ context.Context, v int) []map[string]Asset { return *new([]map[string]Asset) })
_, known, _, _, err = await(o2)
assert.True(t, known)
assert.NoError(t, err)
})
t.Run("ApplyAssetMapMap", func(t *testing.T) {
o2 := out.ApplyAssetMapMap(func(v int) map[string]map[string]Asset { return *new(map[string]map[string]Asset) })
_, known, _, _, err := await(o2)
assert.True(t, known)
assert.NoError(t, err)
o2 = out.ApplyAssetMapMapWithContext(context.Background(), func(_ context.Context, v int) map[string]map[string]Asset { return *new(map[string]map[string]Asset) })
_, known, _, _, err = await(o2)
assert.True(t, known)
assert.NoError(t, err)
})
t.Run("ApplyAssetArrayArray", func(t *testing.T) {
o2 := out.ApplyAssetArrayArray(func(v int) [][]Asset { return *new([][]Asset) })
_, known, _, _, err := await(o2)
assert.True(t, known)
assert.NoError(t, err)
o2 = out.ApplyAssetArrayArrayWithContext(context.Background(), func(_ context.Context, v int) [][]Asset { return *new([][]Asset) })
_, known, _, _, err = await(o2)
assert.True(t, known)
assert.NoError(t, err)
})
t.Run("ApplyAssetOrArchive", func(t *testing.T) {
o2 := out.ApplyAssetOrArchive(func(v int) AssetOrArchive { return *new(AssetOrArchive) })
_, known, _, _, err := await(o2)
assert.True(t, known)
assert.NoError(t, err)
o2 = out.ApplyAssetOrArchiveWithContext(context.Background(), func(_ context.Context, v int) AssetOrArchive { return *new(AssetOrArchive) })
_, known, _, _, err = await(o2)
assert.True(t, known)
assert.NoError(t, err)
})
t.Run("ApplyAssetOrArchiveArray", func(t *testing.T) {
o2 := out.ApplyAssetOrArchiveArray(func(v int) []AssetOrArchive { return *new([]AssetOrArchive) })
_, known, _, _, err := await(o2)
assert.True(t, known)
assert.NoError(t, err)
o2 = out.ApplyAssetOrArchiveArrayWithContext(context.Background(), func(_ context.Context, v int) []AssetOrArchive { return *new([]AssetOrArchive) })
_, known, _, _, err = await(o2)
assert.True(t, known)
assert.NoError(t, err)
})
t.Run("ApplyAssetOrArchiveMap", func(t *testing.T) {
o2 := out.ApplyAssetOrArchiveMap(func(v int) map[string]AssetOrArchive { return *new(map[string]AssetOrArchive) })
_, known, _, _, err := await(o2)
assert.True(t, known)
assert.NoError(t, err)
o2 = out.ApplyAssetOrArchiveMapWithContext(context.Background(), func(_ context.Context, v int) map[string]AssetOrArchive { return *new(map[string]AssetOrArchive) })
_, known, _, _, err = await(o2)
assert.True(t, known)
assert.NoError(t, err)
})
t.Run("ApplyAssetOrArchiveArrayMap", func(t *testing.T) {
o2 := out.ApplyAssetOrArchiveArrayMap(func(v int) map[string][]AssetOrArchive { return *new(map[string][]AssetOrArchive) })
_, known, _, _, err := await(o2)
assert.True(t, known)
assert.NoError(t, err)
o2 = out.ApplyAssetOrArchiveArrayMapWithContext(context.Background(), func(_ context.Context, v int) map[string][]AssetOrArchive { return *new(map[string][]AssetOrArchive) })
_, known, _, _, err = await(o2)
assert.True(t, known)
assert.NoError(t, err)
})
t.Run("ApplyAssetOrArchiveMapArray", func(t *testing.T) {
o2 := out.ApplyAssetOrArchiveMapArray(func(v int) []map[string]AssetOrArchive { return *new([]map[string]AssetOrArchive) })
_, known, _, _, err := await(o2)
assert.True(t, known)
assert.NoError(t, err)
o2 = out.ApplyAssetOrArchiveMapArrayWithContext(context.Background(), func(_ context.Context, v int) []map[string]AssetOrArchive { return *new([]map[string]AssetOrArchive) })
_, known, _, _, err = await(o2)
assert.True(t, known)
assert.NoError(t, err)
})
t.Run("ApplyAssetOrArchiveMapMap", func(t *testing.T) {
o2 := out.ApplyAssetOrArchiveMapMap(func(v int) map[string]map[string]AssetOrArchive { return *new(map[string]map[string]AssetOrArchive) })
_, known, _, _, err := await(o2)
assert.True(t, known)
assert.NoError(t, err)
o2 = out.ApplyAssetOrArchiveMapMapWithContext(context.Background(), func(_ context.Context, v int) map[string]map[string]AssetOrArchive {
return *new(map[string]map[string]AssetOrArchive)
})
_, known, _, _, err = await(o2)
assert.True(t, known)
assert.NoError(t, err)
})
t.Run("ApplyAssetOrArchiveArrayArray", func(t *testing.T) {
o2 := out.ApplyAssetOrArchiveArrayArray(func(v int) [][]AssetOrArchive { return *new([][]AssetOrArchive) })
_, known, _, _, err := await(o2)
assert.True(t, known)
assert.NoError(t, err)
o2 = out.ApplyAssetOrArchiveArrayArrayWithContext(context.Background(), func(_ context.Context, v int) [][]AssetOrArchive { return *new([][]AssetOrArchive) })
_, known, _, _, err = await(o2)
assert.True(t, known)
assert.NoError(t, err)
})
t.Run("ApplyBool", func(t *testing.T) {
o2 := out.ApplyBool(func(v int) bool { return *new(bool) })
_, known, _, _, err := await(o2)
assert.True(t, known)
assert.NoError(t, err)
o2 = out.ApplyBoolWithContext(context.Background(), func(_ context.Context, v int) bool { return *new(bool) })
_, known, _, _, err = await(o2)
assert.True(t, known)
assert.NoError(t, err)
})
t.Run("ApplyBoolPtr", func(t *testing.T) {
o2 := out.ApplyBoolPtr(func(v int) *bool { return *new(*bool) })
_, known, _, _, err := await(o2)
assert.True(t, known)
assert.NoError(t, err)
o2 = out.ApplyBoolPtrWithContext(context.Background(), func(_ context.Context, v int) *bool { return *new(*bool) })
_, known, _, _, err = await(o2)
assert.True(t, known)
assert.NoError(t, err)
})
t.Run("ApplyBoolArray", func(t *testing.T) {
o2 := out.ApplyBoolArray(func(v int) []bool { return *new([]bool) })
_, known, _, _, err := await(o2)
assert.True(t, known)
assert.NoError(t, err)
o2 = out.ApplyBoolArrayWithContext(context.Background(), func(_ context.Context, v int) []bool { return *new([]bool) })
_, known, _, _, err = await(o2)
assert.True(t, known)
assert.NoError(t, err)
})
t.Run("ApplyBoolMap", func(t *testing.T) {
o2 := out.ApplyBoolMap(func(v int) map[string]bool { return *new(map[string]bool) })
_, known, _, _, err := await(o2)
assert.True(t, known)
assert.NoError(t, err)
o2 = out.ApplyBoolMapWithContext(context.Background(), func(_ context.Context, v int) map[string]bool { return *new(map[string]bool) })
_, known, _, _, err = await(o2)
assert.True(t, known)
assert.NoError(t, err)
})
t.Run("ApplyBoolArrayMap", func(t *testing.T) {
o2 := out.ApplyBoolArrayMap(func(v int) map[string][]bool { return *new(map[string][]bool) })
_, known, _, _, err := await(o2)
assert.True(t, known)
assert.NoError(t, err)
o2 = out.ApplyBoolArrayMapWithContext(context.Background(), func(_ context.Context, v int) map[string][]bool { return *new(map[string][]bool) })
_, known, _, _, err = await(o2)
assert.True(t, known)
assert.NoError(t, err)
})
t.Run("ApplyBoolMapArray", func(t *testing.T) {
o2 := out.ApplyBoolMapArray(func(v int) []map[string]bool { return *new([]map[string]bool) })
_, known, _, _, err := await(o2)
assert.True(t, known)
assert.NoError(t, err)
o2 = out.ApplyBoolMapArrayWithContext(context.Background(), func(_ context.Context, v int) []map[string]bool { return *new([]map[string]bool) })
_, known, _, _, err = await(o2)
assert.True(t, known)
assert.NoError(t, err)
})
t.Run("ApplyBoolMapMap", func(t *testing.T) {
o2 := out.ApplyBoolMapMap(func(v int) map[string]map[string]bool { return *new(map[string]map[string]bool) })
_, known, _, _, err := await(o2)
assert.True(t, known)
assert.NoError(t, err)
o2 = out.ApplyBoolMapMapWithContext(context.Background(), func(_ context.Context, v int) map[string]map[string]bool { return *new(map[string]map[string]bool) })
_, known, _, _, err = await(o2)
assert.True(t, known)
assert.NoError(t, err)
})
t.Run("ApplyBoolArrayArray", func(t *testing.T) {
o2 := out.ApplyBoolArrayArray(func(v int) [][]bool { return *new([][]bool) })
_, known, _, _, err := await(o2)
assert.True(t, known)
assert.NoError(t, err)
o2 = out.ApplyBoolArrayArrayWithContext(context.Background(), func(_ context.Context, v int) [][]bool { return *new([][]bool) })
_, known, _, _, err = await(o2)
assert.True(t, known)
assert.NoError(t, err)
})
t.Run("ApplyFloat64", func(t *testing.T) {
o2 := out.ApplyFloat64(func(v int) float64 { return *new(float64) })
_, known, _, _, err := await(o2)
assert.True(t, known)
assert.NoError(t, err)
o2 = out.ApplyFloat64WithContext(context.Background(), func(_ context.Context, v int) float64 { return *new(float64) })
_, known, _, _, err = await(o2)
assert.True(t, known)
assert.NoError(t, err)
})
t.Run("ApplyFloat64Ptr", func(t *testing.T) {
o2 := out.ApplyFloat64Ptr(func(v int) *float64 { return *new(*float64) })
_, known, _, _, err := await(o2)
assert.True(t, known)
assert.NoError(t, err)
o2 = out.ApplyFloat64PtrWithContext(context.Background(), func(_ context.Context, v int) *float64 { return *new(*float64) })
_, known, _, _, err = await(o2)
assert.True(t, known)
assert.NoError(t, err)
})
t.Run("ApplyFloat64Array", func(t *testing.T) {
o2 := out.ApplyFloat64Array(func(v int) []float64 { return *new([]float64) })
_, known, _, _, err := await(o2)
assert.True(t, known)
assert.NoError(t, err)
o2 = out.ApplyFloat64ArrayWithContext(context.Background(), func(_ context.Context, v int) []float64 { return *new([]float64) })
_, known, _, _, err = await(o2)
assert.True(t, known)
assert.NoError(t, err)
})
t.Run("ApplyFloat64Map", func(t *testing.T) {
o2 := out.ApplyFloat64Map(func(v int) map[string]float64 { return *new(map[string]float64) })
_, known, _, _, err := await(o2)
assert.True(t, known)
assert.NoError(t, err)
o2 = out.ApplyFloat64MapWithContext(context.Background(), func(_ context.Context, v int) map[string]float64 { return *new(map[string]float64) })
_, known, _, _, err = await(o2)
assert.True(t, known)
assert.NoError(t, err)
})
t.Run("ApplyFloat64ArrayMap", func(t *testing.T) {
o2 := out.ApplyFloat64ArrayMap(func(v int) map[string][]float64 { return *new(map[string][]float64) })
_, known, _, _, err := await(o2)
assert.True(t, known)
assert.NoError(t, err)
o2 = out.ApplyFloat64ArrayMapWithContext(context.Background(), func(_ context.Context, v int) map[string][]float64 { return *new(map[string][]float64) })
_, known, _, _, err = await(o2)
assert.True(t, known)
assert.NoError(t, err)
})
t.Run("ApplyFloat64MapArray", func(t *testing.T) {
o2 := out.ApplyFloat64MapArray(func(v int) []map[string]float64 { return *new([]map[string]float64) })
_, known, _, _, err := await(o2)
assert.True(t, known)
assert.NoError(t, err)
o2 = out.ApplyFloat64MapArrayWithContext(context.Background(), func(_ context.Context, v int) []map[string]float64 { return *new([]map[string]float64) })
_, known, _, _, err = await(o2)
assert.True(t, known)
assert.NoError(t, err)
})
t.Run("ApplyFloat64MapMap", func(t *testing.T) {
o2 := out.ApplyFloat64MapMap(func(v int) map[string]map[string]float64 { return *new(map[string]map[string]float64) })
_, known, _, _, err := await(o2)
assert.True(t, known)
assert.NoError(t, err)
o2 = out.ApplyFloat64MapMapWithContext(context.Background(), func(_ context.Context, v int) map[string]map[string]float64 {
return *new(map[string]map[string]float64)
})
_, known, _, _, err = await(o2)
assert.True(t, known)
assert.NoError(t, err)
})
t.Run("ApplyFloat64ArrayArray", func(t *testing.T) {
o2 := out.ApplyFloat64ArrayArray(func(v int) [][]float64 { return *new([][]float64) })
_, known, _, _, err := await(o2)
assert.True(t, known)
assert.NoError(t, err)
o2 = out.ApplyFloat64ArrayArrayWithContext(context.Background(), func(_ context.Context, v int) [][]float64 { return *new([][]float64) })
_, known, _, _, err = await(o2)
assert.True(t, known)
assert.NoError(t, err)
})
t.Run("ApplyID", func(t *testing.T) {
o2 := out.ApplyID(func(v int) ID { return *new(ID) })
_, known, _, _, err := await(o2)
assert.True(t, known)
assert.NoError(t, err)
o2 = out.ApplyIDWithContext(context.Background(), func(_ context.Context, v int) ID { return *new(ID) })
_, known, _, _, err = await(o2)
assert.True(t, known)
assert.NoError(t, err)
})
t.Run("ApplyIDPtr", func(t *testing.T) {
o2 := out.ApplyIDPtr(func(v int) *ID { return *new(*ID) })
_, known, _, _, err := await(o2)
assert.True(t, known)
assert.NoError(t, err)
o2 = out.ApplyIDPtrWithContext(context.Background(), func(_ context.Context, v int) *ID { return *new(*ID) })
_, known, _, _, err = await(o2)
assert.True(t, known)
assert.NoError(t, err)
})
t.Run("ApplyIDArray", func(t *testing.T) {
o2 := out.ApplyIDArray(func(v int) []ID { return *new([]ID) })
_, known, _, _, err := await(o2)
assert.True(t, known)
assert.NoError(t, err)
o2 = out.ApplyIDArrayWithContext(context.Background(), func(_ context.Context, v int) []ID { return *new([]ID) })
_, known, _, _, err = await(o2)
assert.True(t, known)
assert.NoError(t, err)
})
t.Run("ApplyIDMap", func(t *testing.T) {
o2 := out.ApplyIDMap(func(v int) map[string]ID { return *new(map[string]ID) })
_, known, _, _, err := await(o2)
assert.True(t, known)
assert.NoError(t, err)
o2 = out.ApplyIDMapWithContext(context.Background(), func(_ context.Context, v int) map[string]ID { return *new(map[string]ID) })
_, known, _, _, err = await(o2)
assert.True(t, known)
assert.NoError(t, err)
})
t.Run("ApplyIDArrayMap", func(t *testing.T) {
o2 := out.ApplyIDArrayMap(func(v int) map[string][]ID { return *new(map[string][]ID) })
_, known, _, _, err := await(o2)
assert.True(t, known)
assert.NoError(t, err)
o2 = out.ApplyIDArrayMapWithContext(context.Background(), func(_ context.Context, v int) map[string][]ID { return *new(map[string][]ID) })
_, known, _, _, err = await(o2)
assert.True(t, known)
assert.NoError(t, err)
})
t.Run("ApplyIDMapArray", func(t *testing.T) {
o2 := out.ApplyIDMapArray(func(v int) []map[string]ID { return *new([]map[string]ID) })
_, known, _, _, err := await(o2)
assert.True(t, known)
assert.NoError(t, err)
o2 = out.ApplyIDMapArrayWithContext(context.Background(), func(_ context.Context, v int) []map[string]ID { return *new([]map[string]ID) })
_, known, _, _, err = await(o2)
assert.True(t, known)
assert.NoError(t, err)
})
t.Run("ApplyIDMapMap", func(t *testing.T) {
o2 := out.ApplyIDMapMap(func(v int) map[string]map[string]ID { return *new(map[string]map[string]ID) })
_, known, _, _, err := await(o2)
assert.True(t, known)
assert.NoError(t, err)
o2 = out.ApplyIDMapMapWithContext(context.Background(), func(_ context.Context, v int) map[string]map[string]ID { return *new(map[string]map[string]ID) })
_, known, _, _, err = await(o2)
assert.True(t, known)
assert.NoError(t, err)
})
t.Run("ApplyIDArrayArray", func(t *testing.T) {
o2 := out.ApplyIDArrayArray(func(v int) [][]ID { return *new([][]ID) })
_, known, _, _, err := await(o2)
assert.True(t, known)
assert.NoError(t, err)
o2 = out.ApplyIDArrayArrayWithContext(context.Background(), func(_ context.Context, v int) [][]ID { return *new([][]ID) })
_, known, _, _, err = await(o2)
assert.True(t, known)
assert.NoError(t, err)
})
t.Run("ApplyArray", func(t *testing.T) {
o2 := out.ApplyArray(func(v int) []interface{} { return *new([]interface{}) })
_, known, _, _, err := await(o2)
assert.True(t, known)
assert.NoError(t, err)
o2 = out.ApplyArrayWithContext(context.Background(), func(_ context.Context, v int) []interface{} { return *new([]interface{}) })
_, known, _, _, err = await(o2)
assert.True(t, known)
assert.NoError(t, err)
})
t.Run("ApplyMap", func(t *testing.T) {
o2 := out.ApplyMap(func(v int) map[string]interface{} { return *new(map[string]interface{}) })
_, known, _, _, err := await(o2)
assert.True(t, known)
assert.NoError(t, err)
o2 = out.ApplyMapWithContext(context.Background(), func(_ context.Context, v int) map[string]interface{} { return *new(map[string]interface{}) })
_, known, _, _, err = await(o2)
assert.True(t, known)
assert.NoError(t, err)
})
t.Run("ApplyArrayMap", func(t *testing.T) {
o2 := out.ApplyArrayMap(func(v int) map[string][]interface{} { return *new(map[string][]interface{}) })
_, known, _, _, err := await(o2)
assert.True(t, known)
assert.NoError(t, err)
o2 = out.ApplyArrayMapWithContext(context.Background(), func(_ context.Context, v int) map[string][]interface{} { return *new(map[string][]interface{}) })
_, known, _, _, err = await(o2)
assert.True(t, known)
assert.NoError(t, err)
})
t.Run("ApplyMapArray", func(t *testing.T) {
o2 := out.ApplyMapArray(func(v int) []map[string]interface{} { return *new([]map[string]interface{}) })
_, known, _, _, err := await(o2)
assert.True(t, known)
assert.NoError(t, err)
o2 = out.ApplyMapArrayWithContext(context.Background(), func(_ context.Context, v int) []map[string]interface{} { return *new([]map[string]interface{}) })
_, known, _, _, err = await(o2)
assert.True(t, known)
assert.NoError(t, err)
})
t.Run("ApplyMapMap", func(t *testing.T) {
o2 := out.ApplyMapMap(func(v int) map[string]map[string]interface{} { return *new(map[string]map[string]interface{}) })
_, known, _, _, err := await(o2)
assert.True(t, known)
assert.NoError(t, err)
o2 = out.ApplyMapMapWithContext(context.Background(), func(_ context.Context, v int) map[string]map[string]interface{} {
return *new(map[string]map[string]interface{})
})
_, known, _, _, err = await(o2)
assert.True(t, known)
assert.NoError(t, err)
})
t.Run("ApplyArrayArray", func(t *testing.T) {
o2 := out.ApplyArrayArray(func(v int) [][]interface{} { return *new([][]interface{}) })
_, known, _, _, err := await(o2)
assert.True(t, known)
assert.NoError(t, err)
o2 = out.ApplyArrayArrayWithContext(context.Background(), func(_ context.Context, v int) [][]interface{} { return *new([][]interface{}) })
_, known, _, _, err = await(o2)
assert.True(t, known)
assert.NoError(t, err)
})
t.Run("ApplyArrayArrayMap", func(t *testing.T) {
o2 := out.ApplyArrayArrayMap(func(v int) map[string][][]interface{} { return *new(map[string][][]interface{}) })
_, known, _, _, err := await(o2)
assert.True(t, known)
assert.NoError(t, err)
o2 = out.ApplyArrayArrayMapWithContext(context.Background(), func(_ context.Context, v int) map[string][][]interface{} { return *new(map[string][][]interface{}) })
_, known, _, _, err = await(o2)
assert.True(t, known)
assert.NoError(t, err)
})
t.Run("ApplyInt", func(t *testing.T) {
o2 := out.ApplyInt(func(v int) int { return *new(int) })
_, known, _, _, err := await(o2)
assert.True(t, known)
assert.NoError(t, err)
o2 = out.ApplyIntWithContext(context.Background(), func(_ context.Context, v int) int { return *new(int) })
_, known, _, _, err = await(o2)
assert.True(t, known)
assert.NoError(t, err)
})
t.Run("ApplyIntPtr", func(t *testing.T) {
o2 := out.ApplyIntPtr(func(v int) *int { return *new(*int) })
_, known, _, _, err := await(o2)
assert.True(t, known)
assert.NoError(t, err)
o2 = out.ApplyIntPtrWithContext(context.Background(), func(_ context.Context, v int) *int { return *new(*int) })
_, known, _, _, err = await(o2)
assert.True(t, known)
assert.NoError(t, err)
})
t.Run("ApplyIntArray", func(t *testing.T) {
o2 := out.ApplyIntArray(func(v int) []int { return *new([]int) })
_, known, _, _, err := await(o2)
assert.True(t, known)
assert.NoError(t, err)
o2 = out.ApplyIntArrayWithContext(context.Background(), func(_ context.Context, v int) []int { return *new([]int) })
_, known, _, _, err = await(o2)
assert.True(t, known)
assert.NoError(t, err)
})
t.Run("ApplyIntMap", func(t *testing.T) {
o2 := out.ApplyIntMap(func(v int) map[string]int { return *new(map[string]int) })
_, known, _, _, err := await(o2)
assert.True(t, known)
assert.NoError(t, err)
o2 = out.ApplyIntMapWithContext(context.Background(), func(_ context.Context, v int) map[string]int { return *new(map[string]int) })
_, known, _, _, err = await(o2)
assert.True(t, known)
assert.NoError(t, err)
})
t.Run("ApplyIntArrayMap", func(t *testing.T) {
o2 := out.ApplyIntArrayMap(func(v int) map[string][]int { return *new(map[string][]int) })
_, known, _, _, err := await(o2)
assert.True(t, known)
assert.NoError(t, err)
o2 = out.ApplyIntArrayMapWithContext(context.Background(), func(_ context.Context, v int) map[string][]int { return *new(map[string][]int) })
_, known, _, _, err = await(o2)
assert.True(t, known)
assert.NoError(t, err)
})
t.Run("ApplyIntMapArray", func(t *testing.T) {
o2 := out.ApplyIntMapArray(func(v int) []map[string]int { return *new([]map[string]int) })
_, known, _, _, err := await(o2)
assert.True(t, known)
assert.NoError(t, err)
o2 = out.ApplyIntMapArrayWithContext(context.Background(), func(_ context.Context, v int) []map[string]int { return *new([]map[string]int) })
_, known, _, _, err = await(o2)
assert.True(t, known)
assert.NoError(t, err)
})
t.Run("ApplyIntMapMap", func(t *testing.T) {
o2 := out.ApplyIntMapMap(func(v int) map[string]map[string]int { return *new(map[string]map[string]int) })
_, known, _, _, err := await(o2)
assert.True(t, known)
assert.NoError(t, err)
o2 = out.ApplyIntMapMapWithContext(context.Background(), func(_ context.Context, v int) map[string]map[string]int { return *new(map[string]map[string]int) })
_, known, _, _, err = await(o2)
assert.True(t, known)
assert.NoError(t, err)
})
t.Run("ApplyIntArrayArray", func(t *testing.T) {
o2 := out.ApplyIntArrayArray(func(v int) [][]int { return *new([][]int) })
_, known, _, _, err := await(o2)
assert.True(t, known)
assert.NoError(t, err)
o2 = out.ApplyIntArrayArrayWithContext(context.Background(), func(_ context.Context, v int) [][]int { return *new([][]int) })
_, known, _, _, err = await(o2)
assert.True(t, known)
assert.NoError(t, err)
})
t.Run("ApplyString", func(t *testing.T) {
o2 := out.ApplyString(func(v int) string { return *new(string) })
_, known, _, _, err := await(o2)
assert.True(t, known)
assert.NoError(t, err)
o2 = out.ApplyStringWithContext(context.Background(), func(_ context.Context, v int) string { return *new(string) })
_, known, _, _, err = await(o2)
assert.True(t, known)
assert.NoError(t, err)
})
t.Run("ApplyStringPtr", func(t *testing.T) {
o2 := out.ApplyStringPtr(func(v int) *string { return *new(*string) })
_, known, _, _, err := await(o2)
assert.True(t, known)
assert.NoError(t, err)
o2 = out.ApplyStringPtrWithContext(context.Background(), func(_ context.Context, v int) *string { return *new(*string) })
_, known, _, _, err = await(o2)
assert.True(t, known)
assert.NoError(t, err)
})
t.Run("ApplyStringArray", func(t *testing.T) {
o2 := out.ApplyStringArray(func(v int) []string { return *new([]string) })
_, known, _, _, err := await(o2)
assert.True(t, known)
assert.NoError(t, err)
o2 = out.ApplyStringArrayWithContext(context.Background(), func(_ context.Context, v int) []string { return *new([]string) })
_, known, _, _, err = await(o2)
assert.True(t, known)
assert.NoError(t, err)
})
t.Run("ApplyStringMap", func(t *testing.T) {
o2 := out.ApplyStringMap(func(v int) map[string]string { return *new(map[string]string) })
_, known, _, _, err := await(o2)
assert.True(t, known)
assert.NoError(t, err)
o2 = out.ApplyStringMapWithContext(context.Background(), func(_ context.Context, v int) map[string]string { return *new(map[string]string) })
_, known, _, _, err = await(o2)
assert.True(t, known)
assert.NoError(t, err)
})
t.Run("ApplyStringArrayMap", func(t *testing.T) {
o2 := out.ApplyStringArrayMap(func(v int) map[string][]string { return *new(map[string][]string) })
_, known, _, _, err := await(o2)
assert.True(t, known)
assert.NoError(t, err)
o2 = out.ApplyStringArrayMapWithContext(context.Background(), func(_ context.Context, v int) map[string][]string { return *new(map[string][]string) })
_, known, _, _, err = await(o2)
assert.True(t, known)
assert.NoError(t, err)
})
t.Run("ApplyStringMapArray", func(t *testing.T) {
o2 := out.ApplyStringMapArray(func(v int) []map[string]string { return *new([]map[string]string) })
_, known, _, _, err := await(o2)
assert.True(t, known)
assert.NoError(t, err)
o2 = out.ApplyStringMapArrayWithContext(context.Background(), func(_ context.Context, v int) []map[string]string { return *new([]map[string]string) })
_, known, _, _, err = await(o2)
assert.True(t, known)
assert.NoError(t, err)
})
t.Run("ApplyStringMapMap", func(t *testing.T) {
o2 := out.ApplyStringMapMap(func(v int) map[string]map[string]string { return *new(map[string]map[string]string) })
_, known, _, _, err := await(o2)
assert.True(t, known)
assert.NoError(t, err)
o2 = out.ApplyStringMapMapWithContext(context.Background(), func(_ context.Context, v int) map[string]map[string]string { return *new(map[string]map[string]string) })
_, known, _, _, err = await(o2)
assert.True(t, known)
assert.NoError(t, err)
})
t.Run("ApplyStringArrayArray", func(t *testing.T) {
o2 := out.ApplyStringArrayArray(func(v int) [][]string { return *new([][]string) })
_, known, _, _, err := await(o2)
assert.True(t, known)
assert.NoError(t, err)
o2 = out.ApplyStringArrayArrayWithContext(context.Background(), func(_ context.Context, v int) [][]string { return *new([][]string) })
_, known, _, _, err = await(o2)
assert.True(t, known)
assert.NoError(t, err)
})
t.Run("ApplyURN", func(t *testing.T) {
o2 := out.ApplyURN(func(v int) URN { return *new(URN) })
_, known, _, _, err := await(o2)
assert.True(t, known)
assert.NoError(t, err)
o2 = out.ApplyURNWithContext(context.Background(), func(_ context.Context, v int) URN { return *new(URN) })
_, known, _, _, err = await(o2)
assert.True(t, known)
assert.NoError(t, err)
})
t.Run("ApplyURNPtr", func(t *testing.T) {
o2 := out.ApplyURNPtr(func(v int) *URN { return *new(*URN) })
_, known, _, _, err := await(o2)
assert.True(t, known)
assert.NoError(t, err)
o2 = out.ApplyURNPtrWithContext(context.Background(), func(_ context.Context, v int) *URN { return *new(*URN) })
_, known, _, _, err = await(o2)
assert.True(t, known)
assert.NoError(t, err)
})
t.Run("ApplyURNArray", func(t *testing.T) {
o2 := out.ApplyURNArray(func(v int) []URN { return *new([]URN) })
_, known, _, _, err := await(o2)
assert.True(t, known)
assert.NoError(t, err)
o2 = out.ApplyURNArrayWithContext(context.Background(), func(_ context.Context, v int) []URN { return *new([]URN) })
_, known, _, _, err = await(o2)
assert.True(t, known)
assert.NoError(t, err)
})
t.Run("ApplyURNMap", func(t *testing.T) {
o2 := out.ApplyURNMap(func(v int) map[string]URN { return *new(map[string]URN) })
_, known, _, _, err := await(o2)
assert.True(t, known)
assert.NoError(t, err)
o2 = out.ApplyURNMapWithContext(context.Background(), func(_ context.Context, v int) map[string]URN { return *new(map[string]URN) })
_, known, _, _, err = await(o2)
assert.True(t, known)
assert.NoError(t, err)
})
t.Run("ApplyURNArrayMap", func(t *testing.T) {
o2 := out.ApplyURNArrayMap(func(v int) map[string][]URN { return *new(map[string][]URN) })
_, known, _, _, err := await(o2)
assert.True(t, known)
assert.NoError(t, err)
o2 = out.ApplyURNArrayMapWithContext(context.Background(), func(_ context.Context, v int) map[string][]URN { return *new(map[string][]URN) })
_, known, _, _, err = await(o2)
assert.True(t, known)
assert.NoError(t, err)
})
t.Run("ApplyURNMapArray", func(t *testing.T) {
o2 := out.ApplyURNMapArray(func(v int) []map[string]URN { return *new([]map[string]URN) })
_, known, _, _, err := await(o2)
assert.True(t, known)
assert.NoError(t, err)
o2 = out.ApplyURNMapArrayWithContext(context.Background(), func(_ context.Context, v int) []map[string]URN { return *new([]map[string]URN) })
_, known, _, _, err = await(o2)
assert.True(t, known)
assert.NoError(t, err)
})
t.Run("ApplyURNMapMap", func(t *testing.T) {
o2 := out.ApplyURNMapMap(func(v int) map[string]map[string]URN { return *new(map[string]map[string]URN) })
_, known, _, _, err := await(o2)
assert.True(t, known)
assert.NoError(t, err)
o2 = out.ApplyURNMapMapWithContext(context.Background(), func(_ context.Context, v int) map[string]map[string]URN { return *new(map[string]map[string]URN) })
_, known, _, _, err = await(o2)
assert.True(t, known)
assert.NoError(t, err)
})
t.Run("ApplyURNArrayArray", func(t *testing.T) {
o2 := out.ApplyURNArrayArray(func(v int) [][]URN { return *new([][]URN) })
_, known, _, _, err := await(o2)
assert.True(t, known)
assert.NoError(t, err)
o2 = out.ApplyURNArrayArrayWithContext(context.Background(), func(_ context.Context, v int) [][]URN { return *new([][]URN) })
_, known, _, _, err = await(o2)
assert.True(t, known)
assert.NoError(t, err)
})
}
// Test that applies return appropriate concrete implementations of Output based on the callback type
{
out := newIntOutput()
@ -1501,7 +575,7 @@ func TestOutputApply(t *testing.T) {
}
})
res5 := All(res3, res4).Apply(func(v interface{}) (interface{}, error) {
res5 := All(res3, res4).ApplyT(func(v interface{}) (interface{}, error) {
vs := v.([]interface{})
res3 := vs[0].(string)
res4 := vs[1].(*myStructType)

16
sdk/go/pulumi/types_test.go
View file

@ -400,11 +400,11 @@ func TestToOutputInputAny(t *testing.T) {
func TestUnsecret(t *testing.T) {
s := ToSecret(String("foo"))
// assert that secret is immediately secret
assert.True(t, s.IsSecret())
assert.True(t, IsSecret(s))
unS := Unsecret(s)
// assert that we do not have a secret
assert.False(t, unS.IsSecret())
assert.False(t, IsSecret(unS))
errChan := make(chan error)
resultChan := make(chan string)
@ -412,7 +412,7 @@ func TestUnsecret(t *testing.T) {
unS.ApplyT(func(v interface{}) (string, error) {
// assert secretness after the output resolves
secretChan <- unS.IsSecret()
secretChan <- IsSecret(unS)
val := v.(string)
if val == "foo" {
// validate the value
@ -442,7 +442,7 @@ func TestUnsecret(t *testing.T) {
func TestSecrets(t *testing.T) {
s := ToSecret(String("foo"))
// assert that secret is immediately secret
assert.True(t, s.IsSecret())
assert.True(t, IsSecret(s))
errChan := make(chan error)
resultChan := make(chan string)
@ -450,7 +450,7 @@ func TestSecrets(t *testing.T) {
s.ApplyT(func(v interface{}) (string, error) {
// assert secretness after the output resolves
secretChan <- s.IsSecret()
secretChan <- IsSecret(s)
val := v.(string)
if val == "foo" {
// validate the value
@ -481,7 +481,7 @@ func TestSecrets(t *testing.T) {
func TestSecretApply(t *testing.T) {
s1 := ToSecret(String("foo"))
// assert that secret is immediately secret
assert.True(t, s1.IsSecret())
assert.True(t, IsSecret(s1))
s2 := StringInput(String("bar"))
errChan := make(chan error)
@ -494,7 +494,7 @@ func TestSecretApply(t *testing.T) {
})
s.ApplyT(func(v interface{}) (string, error) {
// assert secretness after the output resolves
secretChan <- s.IsSecret()
secretChan <- IsSecret(s)
val := v.(string)
if val == "foobar" {
// validate the value
@ -556,7 +556,7 @@ func TestNil(t *testing.T) {
assert.NoError(t, err)
assert.Equal(t, nil, v)
bo := ao.ApplyBool(func(x interface{}) bool {
bo := ao.ApplyT(func(x interface{}) bool {
return x == nil
})
v, known, secret, deps, err = await(bo)

2
tests/integration/stack_reference/go/step1/main.go
View file

@ -27,7 +27,7 @@ func main() {
errChan := make(chan error)
results := make(chan []string)
_ = val.ApplyStringArray(func(v []string) ([]string, error) {
_ = val.ApplyT(func(v []string) ([]string, error) {
if len(v) != 2 || v[0] != "a" || v[1] != "b" {
errChan <- fmt.Errorf("invalid result")
return nil, fmt.Errorf("invalid result")

2
tests/integration/stack_reference/go/step2/main.go
View file

@ -29,7 +29,7 @@ func main() {
results := make(chan []string)
secret := make(chan bool)
_ = val.ApplyStringArray(func(v []string) ([]string, error) {
_ = val.ApplyT(func(v []string) ([]string, error) {
if len(v) != 2 || v[0] != "a" || v[1] != "b" {
errChan <- fmt.Errorf("invalid result")